package com.kcwl.carrier.infrastructure.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;

//import org.apache.commons.lang3.StringUtils;

public class SysUtil {

	/**
	 * 字符川两端去空格 160空格会被转化为普通空格
	 *
	 * @param str
	 * @return
	 */
	public static String trim(String str) {
		if (null == str) {
			return null;
		}
		char c = 160;
		str.replace(c, ' ');
		return str.trim();
	}

	public static boolean notEmpty(String str) {
		return !isEmpty(str);
	}

	/**
	 * trim之后的String是否为null或空字符串
	 *
	 * @param str
	 * @return true:null false:非null
	 */
	public static boolean isEmpty(String str) {
        return str == null || trim(str).isEmpty();
    }

	/**
	 * 是否包含空字符串
	 *
	 * @param strs
	 * @return true:空字符串 false:非空
	 */
	public static boolean hasEmpty(Object... strs) {
		for (Object str : strs) {
			if (str == null || trim(toStr(str)).isEmpty()) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 所有字符串都是空串
	 *
	 * @param strs
	 * @return true:空字符串 false:非空
	 */
	public static boolean allEmpty(Object... strs) {
		for (Object str : strs) {
			if (!hasEmpty(str)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * List是否为空
	 *
	 * @param list
	 * @return true:空  false:不为空
	 */
	@SuppressWarnings("rawtypes")
	public static boolean isEmpty(Collection list) {
		return list == null || list.isEmpty();
	}

	/**
	 * List是否为空
	 *
	 * @param list
	 * @return true:不为空  false:空
	 */
	@SuppressWarnings("rawtypes")
	public static boolean notEmpty(List list) {
		return null != list && !list.isEmpty();
	}

	/**
	 * 将对象转换为String(null转换为空串)
	 *
	 * @param o
	 * @return
	 */
	public static String toStr(Object o) {
		if (null == o) {
			return "";
		}
		return trim(o.toString());
	}

	/**
	 * 将对象转换为String 并trim (null转换为null)
	 *
	 * @param o
	 * @return
	 */
	public static String parseString(Object o) {
		if (null == o) {
			return null;
		}
		return trim(o.toString());
	}

	/**
	 * 将对象转换为String 并trim (null转换为null)
	 *
	 * @return
	 */
	public static <T,V> String parseString(Map<T,V> map, T propName) {
		if(map == null){
			return null;
		}
		return parseString(map.get(propName));
	}

	/**
	 * 将对象转换为int(null转换为0)
	 *
	 * @param o
	 * @return
	 */
	public static int toInt(Object o) {
		if (null == o) {
			return 0;
		}
		return Integer.parseInt(o.toString());
	}

	/**
	 * 将对象转换为Integer
	 *
	 * @param o
	 * @return
	 */
	public static Integer parseInteger(Object o) {
		if (null == o) {
			return null;
		}
		if (o instanceof Integer) {
			return (Integer) o;
		} else {
			return Integer.parseInt(o.toString());
		}
	}

	public static <T,V> Integer parseInteger(Map<T,V> map, T propName) {
		if(map == null){
			return null;
		}
		return parseInteger(map.get(propName));
	}

	/**
	 * 将对象转换为long(null转换为0)
	 *
	 * @param o
	 * @return
	 */
	public static long toLong(Object o) {
		if (null == o) {
			return 0;
		}
		return Long.parseLong(o.toString());
	}

	public static <T,V> long toLong(Map<T,V> map, T propName) {
		if(map == null){
			return 0;
		}
		return toLong(map.get(propName));
	}

	/**
	 * 将对象转换为Long
	 *
	 * @param o
	 * @return
	 */
	public static Long parseLong(Object o) {
		if (null == o) {
			return null;
		}
		if (o instanceof Long) {
			return (Long) o;
		} else {
			return Long.valueOf(o.toString());
		}
	}
	public static <T,V> Long parseLong(Map<T,V> map, T propName) {
		if(map == null){
			return null;
		}
		return parseLong(map.get(propName));
	}

	/**
	 * 将对象转换为double(null转换为0)
	 *
	 * @param o
	 * @return
	 */
	public static double toDouble(Object o) {
		if (null == o) {
			return 0;
		}
		return Double.parseDouble(o.toString());
	}

	/**
	 * 将对象转换为Double
	 * @return
	 */
	public static Double parseDouble(Object value) {
		if (value == null||"".equals(value)) {
			return null;
		}
		if (value instanceof Double) {
			return (Double) value;
		}
		String valueStr = value.toString();
		return Double.parseDouble(trim(valueStr));
	}
	/**
	 * 将对象转换为Float
	 *
	 * @return
	 */
	public static Float parseFloat(Object value) {
		if (value == null) {
			return null;
		}
		if (value instanceof Float) {
			return (Float) value;
		}
		String valueStr = value.toString();
		return Float.parseFloat(trim(valueStr));
	}
	public static <T,V> Double parseDouble(Map<T,V> map, T propName) {
		if(map == null){
			return null;
		}
		return parseDouble(map.get(propName));
	}

	/**
	 * 将对象转换为BigDecimal(null转换为0)
	 *
	 * @param o
	 * @return
	 */
	public static BigDecimal toBigDecimal(Object o) {
		BigDecimal bd = new BigDecimal("0");
		if (o == null) {
			return bd;
		}
		if (o instanceof BigDecimal) {
			return (BigDecimal) o;
		}
		return new BigDecimal(o.toString());
	}

	/**
	 * 比较两个trim 之后的字符串是否相等
	 *
	 * @param a
	 * @param b
	 * @return
	 */
	public static boolean equalTrim(String a, String b) {
		if (null == a || null == b) {
			return false;
		}
		return trim(a).equals(trim(b));
	}

	/**
	 * 比较字符串是否相等 都空为不等
	 *
	 * @param a
	 * @param b
	 * @return
	 */
	public static boolean equal(String a, String b) {
		if (null == a || null == b) {
			return false;
		}
		return a.equals(b);
	}

	/**
	 * 将两个字符串都转换成小写，然后比较两个字符串
	 *
	 * @param a
	 * @param b
	 * @return
	 */
	public static boolean equalLowCase(String a, String b) {
		if (null == a || null == b) {
			return false;
		}
		return a.toLowerCase().equals(b.toLowerCase());
	}

	/**
	 * 包含字符串 不区分大小写
	 *
	 * @param arr
	 * @param value
	 * @return
	 */
	public static boolean lowCaseContains(String[] arr, String value) {
		for (String str : arr) {
			if (equalLowCase(str, value)) {
				return true;
			}
		}
		return false;
	}

	public static <T> Collection<T> nullToEmpty(Collection<T> col) {
		if (col == null) {
			return new ArrayList<T>();
		} else {
			return col;
		}
	}

	/**
	 * 创建一个set
	 *
	 * @param ts
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <T> Set<T> asSet(T... ts) {
		Set<T> set = new HashSet<T>();
		set.addAll(Arrays.asList(ts));
		return set;
	}

	/**
	 * 将list转化为string 中间用 joinStr 连接
	 *
	 * @param list
	 * @param joinStr
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static String listToString(List list, String joinStr) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < list.size(); i++) {
			if (i != 0) {
				sb.append(joinStr);
			}
			sb.append(SysUtil.toStr(list.get(i)));
		}
		return sb.toString();
	}

//	/**
//	 * 将List转化为String(中间用 joinStr连接)
//	 *
//	 * @param list
//	 * @param joinStr
//	 * @return 简洁版
//	 */
//	public static <T> String listToStr(List<T> list, String joinStr) {
//		String str = StringUtils.join(list.toArray(), ",");
//		return str;
//	}

//	/**
//	 * 将String转化为List(中间用 joinStr连接)
//	 *
//	 * @param list
//	 * @param joinStr
//	 * @return 简洁版
//	 */
	@SuppressWarnings("unchecked")
//	public static <T> List<T> strToList(String content, String split) {
//		List<T> list = new ArrayList<T>();
//		String arr[] = StringUtils.split(content, split);
//		for(String str : arr){
//			list.add((T)str);
//		}
//		return list;
//	}

	public static List<String> strToStrList(String content, String split) {
		List<String> list = new ArrayList<String>();
		String[] idArr = content.split(split);
		for (int i = 0; i < idArr.length; i++) {
			if (!isEmpty(idArr[i])) {
				list.add(idArr[i]);
			}
		}
		return list;
	}

	public static List<Long> strToLongList(String content, String split) {
		List<Long> list = new ArrayList<Long>();
		String[] idArr = content.split(split);
		for (int i = 0; i < idArr.length; i++) {
			Long id = parseLong(idArr[i]);
			if (null != id) {
				list.add(id);
			}
		}
		return list;
	}

	/**
	 * 去掉list中的空和空字符串 并对保留的字符串去掉两端的空格
	 *
	 * @param list
	 * @return
	 */
	public static List<String> trimList(List<String> list) {
		List<String> resList = new ArrayList<String>();
		for (String str : list) {
			if (!isEmpty(str)) {
				resList.add(trim(str));
			}
		}
		return resList;
	}

	/**
	 * 将 list中保存的对象的propName属性重新组成list反回
	 *
	 * @param list
	 * @param propName
	 * @param valueClass
	 * @return
	 */
	public static <T, V> List<V> getPropList(Iterable<T> list, String propName, Class<V> valueClass) {
		List<V> resList = new ArrayList<V>();
		for (T t : list) {
			V value = MethodUtil.invoteGet(t, propName, valueClass);
			resList.add(value);
		}
		return resList;
	}

	/**
	 * 将 list中保存的对象的propName属性重新组成list反回
	 *
	 * @param list
	 * @param propName
	 * @return
	 */
	public static <T> List<T> subListByProp(Collection<T> list, String propName, Object value) {
		List<T> resList = new ArrayList<T>();
		if (value == null) {
			return resList;
		}
		for (T t : list) {
			Object getValue = MethodUtil.invoteGet(t, propName);
			if (value.equals(getValue)) {
				resList.add(t);
			}
		}
		return resList;
	}

	/**
	 * 计算 相加
	 *
	 * @param a
	 * @param b
	 * @return
	 */
	public static BigDecimal addBigDecimal(BigDecimal a, Object b) {
		if (a == null && b == null) {
			return new BigDecimal("0");
		}
		if (b == null) {
			return a;
		}
		if (a == null) {
			return toBigDecimal(b);
		}
		return a.add(toBigDecimal(b));
	}

	/**
	 * 指定范围随机数字
	 * 含min不含max 且min不能大于等于max
	 * @param min
	 * @param max
	 * @return
	 */
	public static double getDoubleRandom(double min,double max){
		return ThreadLocalRandom.current().nextDouble(min, max);
	}

	/**
	 * 获取指定位数小数
	 * 方式：四舍五入
	 * @param num
	 * @param decimal
	 * @return
	 */
	public static double getDoubleDecimalNum(double num,int decimal){
		return new BigDecimal(num).setScale(decimal,RoundingMode.HALF_UP).doubleValue();
	}

	/**
	 * 将对象转换为Byte
	 *
	 * @param o
	 * @return
	 */
	public static Byte parseByte(Object o) {
		if (null == o) {
			return null;
		}
		if (o instanceof Byte) {
			return (Byte) o;
		} else {
			return Byte.parseByte(o.toString());
		}
	}

	public static <T,V> Byte parseByte(Map<T,V> map, T propName) {
		if(map == null){
			return null;
		}
		return parseByte(map.get(propName));
	}

}
